#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
from strSQL.maceracion import strSelectMaceracion
from strSQL.basicas import strNextValCodigo
from strSQL.recepcion_uva import strSelectFiltroRecepcionUva
from strSQL.maceracion import strSelectMaceracionRecepcionUva
from psycopg2 import connect
import completion
import comunes
from pyBusqueda import pyBusqueda
import proceso
import treetohtml


(CODIGO_MACERACION,
 VOLUMEN_MACERACION,
 CODIGO_ESTANQUE,
 DESCRIPCION_ESTANQUE,
 FECHA,
 HORA,
 OBSERVACION,
 ORIGEN,
 CODIGO_TEMPORADA,
 DESCRIPCION_TEMPORADA) = range(10)

class wnMaceracion(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnProceso"):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnProceso.maximize()
            self.frm_padre = self.wnProceso
            self.padre 
        else:
            self.frm_padre = padre.frm_padre
            
        self.crea_columnas()
        self.carga_datos()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_MACERACION, "Código", "str"])
        columnas.append ([DESCRIPCION_ESTANQUE, "Estanque", "str"])
        columnas.append ([VOLUMEN_MACERACION, "Volumen", "str"])
        columnas.append ([FECHA, "Fecha","dte"])
        columnas.append ([HORA, "Hora", "str"])
        columnas.append ([OBSERVACION, "Observación", "str"])
        columnas.append ([DESCRIPCION_TEMPORADA, "Temporada", "str"])
        
        self.carga_datos()
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeProceso)
        self.col_data = [(x[0], x[2]) for x in columnas]
        
        
    def on_btnImprimir_clicked(self, btn=None):
        t = treetohtml.TreeToHTML(self.treeProceso,"Maceración", self.col_data)
        t.show()
        
    def carga_datos(self):
        self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectMaceracion)
        self.treeProceso.set_model(self.modelo)

    def on_btnAnadir_clicked(self, btn=None, data=None):
        dlg = dlgMaceracion(self.cnx, self.frm_padre, False)
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        dlg.entFecha.set_date(datetime.date.today())
        dlg.entHora.set_text("%s:%s" % (hora, minuto))
        dlg.editando = False
        response = dlg.dlgMaceracion.run()
        if response == gtk.RESPONSE_OK:
            self.carga_datos()
    
    def on_btnQuitar_clicked(self, btn=None):
        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        codigo = model.get_value(it, CODIGO_MACERACION)
        cuartel = model.get_value(it, DESCRIPCION_ESTANQUE)
        fecha = model.get_value(it, FECHA).split()[0]
        
        if dialogos.yesno("¿Desea eliminar la RecepcionUva <b>%s, cuartel %s del %s</b>?\nEsta acción no se puede deshacer\n" % (codigo, cuartel, fecha), self.frm_padre) == gtk.RESPONSE_YES:
            llaves = {'codigo_maceracion':codigo}
            self.cursor.execute("begin")
            try:
                sql = ifd.deleteFromDict('traza.recepcion_maceracion', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.control', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.aplicacion_producto', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.maceracion', llaves)
                self.cursor.execute(sql, llaves)
                model.remove(it)
                self.cursor.execute("commit")
            except:
                self.cursor.execute("rollback")
                print sys.exc_info()[1]
                dialogos.error("<b>NO SE PUEDE ELIMINAR</b>\nLa Maceración de la <b>%s</b> se encuentra relacionado con Módulo Control."%cuartel)
        
    def on_btnPropiedades_clicked(self, btn=None):

        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        
        dlg = dlgMaceracion(self.cnx, self.frm_padre, False)
        dlg.entCodigoMaceracion.set_text(model.get_value(it, CODIGO_MACERACION))
        dlg.spnVolumen.set_value(float(model.get_value(it, VOLUMEN_MACERACION)))
        dlg.codigo_estanque = dlg.pecEstanque.select(model.get_value(it, DESCRIPCION_ESTANQUE), 1)
        
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA).split()[0])
        
        dlg.entFecha.set_date(fecha)
        dlg.entHora.set_text(model.get_value(it, HORA))
        dlg.chkOrigen.set_active(model.get_value(it, ORIGEN) == "S")
        
        buf = dlg.txtObservacion.get_buffer()
        texto = ""
        if len(model[0]) > OBSERVACION:
            texto = model.get_value(it, OBSERVACION)
        
        if texto is None:
            texto = ""
        buf.set_text(texto)
        dlg.txtObservacion.set_buffer(buf)
        
        dlg.aplicacion.carga_modelo(model.get_value(it, CODIGO_MACERACION), "maceracion")
        dlg.control.carga_modelo(model.get_value(it, CODIGO_MACERACION), "maceracion")
        dlg.relacion.carga_modelo(model.get_value(it, CODIGO_MACERACION))
        
        dlg.entTemporada.set_text(model.get_value(it, DESCRIPCION_TEMPORADA))
        dlg.codigo_temporada = model.get_value(it, CODIGO_TEMPORADA)
        dlg.pecTemporada.set_selected(True)
        
        dlg.editando = True
        
        response = dlg.dlgMaceracion.run()
        if response == gtk.RESPONSE_OK:
            self.modelo.clear()
            self.carga_datos()
            
    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Maceración")
            
    def on_treeProceso_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()


class dlgMaceracion(GladeConnect):
    
    def __init__(self, conexion=None, padre=None, editando=None):
        GladeConnect.__init__(self, "glade/wnProceso.glade", "dlgMaceracion")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        #self.spnVolumen.grab_focus()
        self.editando = editando
        self.frm_padre = padre
        
        self.pecEstanque = completion.CompletionEstanque(self.entEstanque,
                self.sel_estanque,
                self.cnx)
        
        self.codigo_estanque = None
        
        self.aplicacion = proceso.vboxAplicacion(self.cnx, self)
        self.ntbMaceracion.append_page(self.aplicacion.vboxAplicacion, gtk.Label("Aplicación"))
        
        self.control = proceso.vboxControl(self.cnx, self)
        self.ntbMaceracion.append_page(self.control.vboxControl, gtk.Label("Control"))
        
        self.relacion = proceso.vboxMaceracionRecepcion(self.cnx, self)
        self.ntbMaceracion.append_page(self.relacion.vboxRelacion, gtk.Label("Detalle recepción de Uva"))
        
        self.pecTemporada = completion.CompletionTemporada(self.entTemporada,
                self.sel_temporada,
                self.cnx)
        
        #<CODIGO comment="PARA SUGERIR LA MAS NUEVA">
        strSelectCodigoTemporada = """SELECT
                                        codigo_temporada,
                                        'Temporada ' || date_part('year', fecha_inicio) || '-' 
                                        || date_part('year', fecha_termino) as descripcion_temporada
                                        FROM traza.temporada
                                        WHERE abierta = TRUE
                                        ORDER BY codigo_temporada desc"""
                                        
        m = ifd.ListStoreFromSQL(self.cnx, strSelectCodigoTemporada)
        self.codigo_temporada = m[0][0]
        self.entTemporada.set_text(m[0][1])
        self.pecTemporada.set_selected(True)
        #</CODIGO>
        
        self.dlgMaceracion.show_all()

    def sel_estanque(self, completion, model, iter):
        self.codigo_estanque = model.get_value(iter, 1)
        
    def sel_temporada(self, completion, model, iter):
        self.codigo_temporada = model.get_value(iter, 1)
        
    def on_chkOrigen_toggled(self, btn=None):

        self.relacion.vboxRelacion.set_sensitive(not btn.get_active())
        self.spnVolumen.set_sensitive(btn.get_active())
        if btn.get_active():
            self.relacion.modelo_relacion.clear()
        
    def on_btnAceptar_clicked(self, btn=None, date=None, cnx=None):
        
        fecha = self.entFecha.get_date()
        hora = self.entHora.get_text()
        
        if hora == "":
            dialogos.error("El campo <b>Hora</b> no puede estar vacío")
            return
        
        if self.codigo_estanque is None:
            dialogos.error("Debe escoger un <b>Estanque</b>")
            return

        if self.chkOrigen.get_active():
            volumen = self.spnVolumen.get_value()
        else:
            volumen = float(self.relacion.entTotal.get_text())

        if volumen <= 0:
            dialogos.error("La <b>volumen</b> debe ser mayor que 0")
            return
        
        if self.entTemporada.get_text() == "":
            dialogos.error("La temporada no puede ser vacia.")
            return

        campos = {}
        llaves = {}
        campos['volumen_maceracion']  = volumen
        campos['codigo_estanque'] = self.codigo_estanque
        campos['hora_maceracion'] = hora
        campos['fecha_maceracion'] = fecha.strftime("%Y/%m/%d")
        campos['codigo_temporada'] = self.codigo_temporada
        if self.chkOrigen.get_active():
            origen = "S"
        else:
            origen = "F"
        campos['origen'] = origen
        
        buf = self.txtObservacion.get_buffer()
        s, e = buf.get_bounds()
        if str(buf.get_text(s, e)) != "None" and str(buf.get_text(s, e)) != "":
            campos['orden_trabajo'] = buf.get_text(s, e)
        else:
            buf.set_text("")
            campos['orden_trabajo'] = buf.get_text(s, e)
        
        self.cursor.execute("BEGIN")
        
        try:
        
            if not self.editando:
                self.cursor.execute(strNextValCodigo % ("maceracion", "maceracion"))
                reg = self.cursor.fetchone()
                campos['codigo_maceracion'] = reg[0]
                llaves['codigo_maceracion'] = reg[0]
                sql = ifd.insertFromDict("traza.maceracion", campos)
            else:
                llaves['codigo_maceracion'] = self.entCodigoMaceracion.get_text()
                sql, campos=ifd.updateFromDict("traza.maceracion", campos, llaves)
    
            self.cursor.execute(sql, campos)
            self.aplicacion.guarda_modelo(llaves['codigo_maceracion'], "maceracion")
            self.control.guarda_modelo(llaves['codigo_maceracion'], "maceracion")
            self.relacion.guarda_modelo("traza.recepcion_maceracion", "codigo_maceracion", llaves['codigo_maceracion'], "codigo_recepcion_uva")
            
        except:
            txt_error = sys.exc_info()[1]
            self.cursor.execute("ROLLBACK")
            dialogos.error("Ha ocurrido un error al intentar registrar los datos", str(txt_error))
            return
            
        self.cursor.execute("COMMIT")
        
        self.dlgMaceracion.hide()
        
    def on_btnCancelar_clicked(self, btn=None):
        self.dlgMaceracion.hide()
        
if __name__ == '__main__':
    cnx = connect("dbname=traza user=traza password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = wnMaceracion(cnx)
    
    gtk.main()
